home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / SampleOscControl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  75.5 KB  |  2,216 lines  |  [TEXT/KAHL]
  1. /* SampleOscControl.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "SampleOscControl.h"
  31. #include "64BitMath.h"
  32. #include "Multisampler.h"
  33. #include "EnvelopeState.h"
  34. #include "Envelope.h"
  35. #include "LFOGenerator.h"
  36. #include "LFOListSpecifier.h"
  37. #include "SampleConsts.h"
  38. #include "Memory.h"
  39. #include "OscillatorSpecifier.h"
  40. #include "FastModulation.h"
  41. #include "ErrorDaemon.h"
  42.  
  43.  
  44. #if !MEMDEBUG && DEBUG
  45.     #undef PRNGCHK
  46.     #define PRNGCHK(x,y,z) ((void)0)
  47. #endif
  48.  
  49.  
  50. /* prototypes for fast playback routines */
  51. static void                        Sample_MonoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  52.                                                 long SampleCount, largefixedsigned* RawBuffer);
  53. static void                        Sample_StereoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  54.                                                 long SampleCount, largefixedsigned* RawBuffer);
  55. static void                        Sample_MonoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  56.                                                 long SampleCount, largefixedsigned* RawBuffer);
  57. static void                        Sample_StereoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  58.                                                 long SampleCount, largefixedsigned* RawBuffer);
  59.  
  60. static void                        Sample_MonoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  61.                                                 long SampleCount, largefixedsigned* RawBuffer);
  62. static void                        Sample_StereoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  63.                                                 long SampleCount, largefixedsigned* RawBuffer);
  64. static void                        Sample_MonoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  65.                                                 long SampleCount, largefixedsigned* RawBuffer);
  66. static void                        Sample_StereoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  67.                                                 long SampleCount, largefixedsigned* RawBuffer);
  68.  
  69. static void                        Sample_MonoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  70.                                                 long SampleCount, largefixedsigned* RawBuffer);
  71. static void                        Sample_StereoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  72.                                                 long SampleCount, largefixedsigned* RawBuffer);
  73. static void                        Sample_MonoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  74.                                                 long SampleCount, largefixedsigned* RawBuffer);
  75. static void                        Sample_StereoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  76.                                                 long SampleCount, largefixedsigned* RawBuffer);
  77.  
  78. static void                        Sample_MonoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  79.                                                 long SampleCount, largefixedsigned* RawBuffer);
  80. static void                        Sample_StereoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  81.                                                 long SampleCount, largefixedsigned* RawBuffer);
  82. static void                        Sample_MonoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  83.                                                 long SampleCount, largefixedsigned* RawBuffer);
  84. static void                        Sample_StereoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  85.                                                 long SampleCount, largefixedsigned* RawBuffer);
  86.  
  87. static void                        Sample_NoOutput(SampleStateRec* State,
  88.                                                 long SampleCount, largefixedsigned* RawBuffer);
  89.  
  90.  
  91. /* this is used for loop control */
  92. typedef enum
  93.     {
  94.         eRepeatingLoop1 EXECUTE(= -18734),
  95.         eRepeatingLoop2,
  96.         eRepeatingLoop3,
  97.         eNoLoop,
  98.         eSampleFinished
  99.     } LoopType;
  100.  
  101.  
  102. /* sample oscillator template information record */
  103. struct SampleTemplateRec
  104.     {
  105.         /* source information for the sample */
  106.         MultiSampleRec*                SampleSourceSelector;
  107.  
  108.         /* sampling rate for final output */
  109.         long                                    FinalOutputSamplingRate;
  110.         /* number of envelope updates per second */
  111.         float                                    EnvelopeTicksPerSecond;
  112.  
  113.         /* values for scaling the frequency of something.  if we were really serious about */
  114.         /* this, we'd traverse all of the oscillators with integral multiples or harmonic */
  115.         /* fractions of the pitch & set their differentials to the same precision as the */
  116.         /* worst oscillator so that they would all stay in sync as time progressed. */
  117.         float                                    FrequencyMultiplier;
  118.         /* this is added after the frequency multiplier is applied */
  119.         float                                    FrequencyAdder;
  120.  
  121.         /* stereo status */
  122.         NumChannelsType                StereoPlayback;
  123.         /* time interpolation flag */
  124.         MyBoolean                            InterpolateThroughTime;
  125.         /* inter-wave interpolation flag */
  126.         MyBoolean                            InterpolateAcrossWaves; /* not used now -- for future use */
  127.         /* include in final output flag */
  128.         MyBoolean                            IncludeInFinalOutput;
  129.  
  130.         /* envelope templates */
  131.         EnvelopeRec*                    LoudnessEnvelopeTemplate;
  132.         LFOListSpecRec*                LoudnessLFOTemplate;
  133.  
  134.         /* miscellaneous control parameters */
  135.         float                                    StereoBias;
  136.         float                                    TimeDisplacement;
  137.         float                                    OverallOscillatorLoudness;
  138.  
  139.         /* error logging facility */
  140.         ErrorDaemonRec*                ErrorDaemon;
  141.  
  142.         /* link for list control */
  143.         SampleTemplateRec*        Next;
  144.     };
  145.  
  146.  
  147. /* sample oscillator state record */
  148. struct SampleStateRec
  149.     {
  150.         /* current sample position into the array */
  151.         LongLongRec                        SamplePosition; /* 32-bit fixed point */
  152.         /* current increment value for the sample position */
  153.         LongLongRec                        SamplePositionDifferential; /* 32-bit fixed point */
  154.         /* envelope tick countdown for pre-start time */
  155.         long                                    PreStartCountdown;
  156.  
  157.         /* function for generating a bunch of sample points */
  158.         void                                    (*SampleGenSamples)(SampleStateRec* State,
  159.                                                         long SampleCount, largefixedsigned* RawBuffer);
  160.  
  161.         /* number of frames in the sample */
  162.         long                                    NumFrames;
  163.         /* sample data pointer.  for mono, it is just an array.  for stereo, the */
  164.         /* samples are interleaved, left channel first */
  165.         void*                                    Data;
  166.         /* number of bits in the data for the sample */
  167.         NumBitsType                        NumBits;
  168.         /* stereo or mono sample */
  169.         NumChannelsType                NumChannels;
  170.  
  171.         /* control parameters for the sample */
  172.         float                                    NaturalFrequency;
  173.         long                                    SamplingRate;
  174.         long                                    OriginPoint;
  175.         long                                    Loop1Start;
  176.         long                                    Loop2Start;
  177.         long                                    Loop3Start;
  178.         long                                    Loop1End;
  179.         long                                    Loop2End;
  180.         long                                    Loop3End;
  181.         /* state information for the current position */
  182.         LoopType                            LoopState; /* which loop is running */
  183.         long                                    CurrentLoopLength; /* current loop length (end - start) */
  184.         long                                    CurrentLoopEnd; /* current loop/total end point */
  185.  
  186.         /* NOTE:  either OverallLoudness or Left/RightLoudness are used, but not both */
  187.         /* current overall loudness for oscillator */
  188.         FastFixedType                    OverallLoudness; /* 15-bit fixed point, 0..1 */
  189.         /* left channel loudness */
  190.         FastFixedType                    LeftLoudness; /* 15-bit fixed point, 0..1 */
  191.         /* right channel loudness */
  192.         FastFixedType                    RightLoudness; /* 15-bit fixed point, 0..1 */
  193.         /* panning position for splitting envelope generator into stereo channels */
  194.         /* 0 = left channel, 0.5 = middle, 1 = right channel */
  195.         FastFixedType                    Panning; /* 15-bit fixed point, 0..1 */
  196.         /* envelope that is generating the loudness information */
  197.         EvalEnvelopeRec*            SampleLoudnessEnvelope;
  198.         /* LFO generators modifying the output of the loudness envelope generator */
  199.         LFOGenRec*                        LoudnessLFOGenerator;
  200.  
  201.         /* this flag is True if the sample data was defined at the specified pitch */
  202.         /* (and the sample vectors are thus valid) or False if there is no sample */
  203.         /* at this pitch (and the arrays are invalid) */
  204.         MyBoolean                            SampleWasDefined;
  205.  
  206.         /* this field contains the overall volume scaling for everything so that we */
  207.         /* can treat the envelopes as always going between 0 and 1. */
  208.         float                                    NoteLoudnessScaling;
  209.  
  210.         /* static information for the sample */
  211.         SampleTemplateRec            Template; /* a copy of the data */
  212.  
  213.         /* link for list control */
  214.         SampleStateRec*                Next;
  215.     };
  216.  
  217.  
  218.  
  219.  
  220. static SampleTemplateRec*                SampleTemplateFreeList = NIL;
  221. static SampleStateRec*                    SampleStateFreeList = NIL;
  222.  
  223.  
  224. /* get rid of all cached memory for state or template records */
  225. void                                    FlushSampleOscControl(void)
  226.     {
  227.         while (SampleTemplateFreeList != NIL)
  228.             {
  229.                 SampleTemplateRec*    Temp;
  230.  
  231.                 Temp = SampleTemplateFreeList;
  232.                 SampleTemplateFreeList = SampleTemplateFreeList->Next;
  233.                 ReleasePtr((char*)Temp);
  234.             }
  235.  
  236.         while (SampleStateFreeList != NIL)
  237.             {
  238.                 SampleStateRec*            Temp;
  239.  
  240.                 Temp = SampleStateFreeList;
  241.                 SampleStateFreeList = SampleStateFreeList->Next;
  242.                 ReleasePtr((char*)Temp);
  243.             }
  244.     }
  245.  
  246.  
  247. #if DEBUG
  248. static void                        CheckValidSampleTemplate(SampleTemplateRec* Object)
  249.     {
  250.         SampleTemplateRec*    Scan;
  251.  
  252.         Scan = SampleTemplateFreeList;
  253.         while (Scan != NIL)
  254.             {
  255.                 if (Scan == Object)
  256.                     {
  257.                         PRERR(ForceAbort,"CheckValidSampleTemplate:  template is on free list");
  258.                     }
  259.                 Scan = Scan->Next;
  260.             }
  261.     }
  262. #else
  263. #define CheckValidSampleTemplate(x) ((void)0)
  264. #endif
  265.  
  266.  
  267. #if DEBUG
  268. static void                        CheckValidSampleState(SampleStateRec* Object)
  269.     {
  270.         SampleStateRec*            Scan;
  271.  
  272.         Scan = SampleStateFreeList;
  273.         while (Scan != NIL)
  274.             {
  275.                 if (Scan == Object)
  276.                     {
  277.                         PRERR(ForceAbort,"CheckValidSampleState:  state is on free list");
  278.                     }
  279.                 Scan = Scan->Next;
  280.             }
  281.     }
  282. #else
  283. #define CheckValidSampleState(x) ((void)0)
  284. #endif
  285.  
  286.  
  287. /* perform one envelope update cycle */
  288. void                                    UpdateSampleEnvelopes(SampleStateRec* State)
  289.     {
  290.         FastFixedType                Temp;
  291.  
  292.         CheckPtrExistence(State);
  293.         CheckValidSampleState(State);
  294.  
  295.         /* this is for the benefit of resampling only -- envelope generators do their */
  296.         /* own pre-origin sequencing */
  297.         if (State->PreStartCountdown > 0)
  298.             {
  299.                 State->PreStartCountdown -= 1;
  300.             }
  301.  
  302.         Temp = State->NoteLoudnessScaling * LFOGenUpdateCycle(State->LoudnessLFOGenerator,
  303.             EnvelopeUpdate(State->SampleLoudnessEnvelope));
  304.         /* fast fixed has a very narrow range, so overflow can't be permitted: */
  305.         /* 15x15->30 bits, with 2 extra bits; we use one for sign and the other */
  306.         /* to permit the representation of 1 and -1. */
  307.         if (State->Template.StereoPlayback == eSampleMono)
  308.             {
  309.                 if (Temp < - Int2FastFixed(1))
  310.                     {
  311.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  312.                             - FastFixed2Float(Temp));
  313.                         Temp = - Int2FastFixed(1);
  314.                     }
  315.                 else if (Temp > Int2FastFixed(1))
  316.                     {
  317.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  318.                             FastFixed2Float(Temp));
  319.                         Temp = Int2FastFixed(1);
  320.                     }
  321.                 State->OverallLoudness = Temp;
  322.             }
  323.          else
  324.             {
  325.                 FastFixedType                LeftVolumeScaling;
  326.                 FastFixedType                RightVolumeScaling;
  327.                 FastFixedType                MaxVolScaling;
  328.                 FastFixedType                MaxTemp;
  329.  
  330.                 LeftVolumeScaling = FastFixedTimesFastFixedToFastFixed(Double2FastFixed(0.5),
  331.                     Int2FastFixed(1) - State->Panning);
  332.                 RightVolumeScaling = FastFixedTimesFastFixedToFastFixed(Double2FastFixed(0.5),
  333.                     Int2FastFixed(1) + State->Panning);
  334.  
  335.                 if (((LeftVolumeScaling >= 0) ? LeftVolumeScaling : (- LeftVolumeScaling))
  336.                     > ((RightVolumeScaling >= 0) ? RightVolumeScaling : (- RightVolumeScaling)))
  337.                     {
  338.                         MaxVolScaling = ((LeftVolumeScaling >= 0)
  339.                             ? LeftVolumeScaling : (- LeftVolumeScaling));
  340.                     }
  341.                  else
  342.                     {
  343.                         MaxVolScaling = ((RightVolumeScaling >= 0)
  344.                             ? RightVolumeScaling : (- RightVolumeScaling));
  345.                     }
  346.                 MaxTemp = Double2FastFixed((float)1 / FastFixed2Float(MaxVolScaling));
  347.                 if (Temp < - MaxTemp)
  348.                     {
  349.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  350.                             - FastFixed2Float(Temp) / FastFixed2Float(MaxTemp));
  351.                         Temp = - MaxTemp;
  352.                     }
  353.                 else if (Temp > MaxTemp)
  354.                     {
  355.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  356.                             FastFixed2Float(Temp) / FastFixed2Float(MaxTemp));
  357.                         Temp = MaxTemp;
  358.                     }
  359.  
  360.                 State->LeftLoudness = FastFixedTimesFastFixedToFastFixed(
  361.                     LeftVolumeScaling,Temp);
  362.                 State->RightLoudness = FastFixedTimesFastFixedToFastFixed(
  363.                     RightVolumeScaling,Temp);
  364.             }
  365.     }
  366.  
  367.  
  368. /* dispose of the sample state record */
  369. void                                    DisposeSampleState(SampleStateRec* State)
  370.     {
  371.         CheckPtrExistence(State);
  372.         CheckValidSampleState(State);
  373.  
  374.         DisposeEnvelopeStateRecord(State->SampleLoudnessEnvelope);
  375.         DisposeLFOGenerator(State->LoudnessLFOGenerator);
  376.  
  377.         State->Next = SampleStateFreeList;
  378.         SampleStateFreeList = State;
  379.     }
  380.  
  381.  
  382. /* dispose of the sample information template */
  383. void                                    DisposeSampleTemplate(SampleTemplateRec* Template)
  384.     {
  385.         CheckPtrExistence(Template);
  386.         CheckValidSampleTemplate(Template);
  387.  
  388.         DisposeMultisample(Template->SampleSourceSelector);
  389.  
  390.         Template->Next = SampleTemplateFreeList;
  391.         SampleTemplateFreeList = Template;
  392.     }
  393.  
  394.  
  395. /* create a new sample template */
  396. SampleTemplateRec*        NewSampleTemplate(struct OscillatorRec* Oscillator,
  397.                                                 float EnvelopeTicksPerSecond, long SamplingRate,
  398.                                                 MyBoolean Stereo, MyBoolean TimeInterp, MyBoolean WaveInterp,
  399.                                                 ErrorDaemonRec* ErrorDaemon)
  400.     {
  401.         SampleTemplateRec*    Template;
  402.  
  403.         CheckPtrExistence(ErrorDaemon);
  404.         CheckPtrExistence(Oscillator);
  405.         ERROR(OscillatorGetWhatKindItIs(Oscillator) != eOscillatorSampled,PRERR(ForceAbort,
  406.             "NewSampleTemplate:  oscillator is not a sample"));
  407.  
  408.         if (SampleTemplateFreeList != NIL)
  409.             {
  410.                 Template = SampleTemplateFreeList;
  411.                 SampleTemplateFreeList = SampleTemplateFreeList->Next;
  412.             }
  413.          else
  414.             {
  415.                 Template = (SampleTemplateRec*)AllocPtrCanFail(sizeof(SampleTemplateRec),
  416.                     "SampleTemplateRec");
  417.                 if (Template == NIL)
  418.                     {
  419.                         return NIL;
  420.                     }
  421.             }
  422.         EXECUTE(Template->Next = (SampleTemplateRec*)0x81818181;)
  423.  
  424.         Template->SampleSourceSelector = NewMultisampleSample(
  425.             OscillatorGetSampleIntervalList(Oscillator));
  426.         if (Template->SampleSourceSelector == NIL)
  427.             {
  428.              FailurePoint1:
  429.                 Template->Next = SampleTemplateFreeList;
  430.                 SampleTemplateFreeList = Template;
  431.                 return NIL;
  432.             }
  433.  
  434.         Template->FinalOutputSamplingRate = SamplingRate;
  435.         Template->EnvelopeTicksPerSecond = EnvelopeTicksPerSecond;
  436.  
  437.         /* it might be better to handle divisor and multiplier separately -- we would */
  438.         /* want to do that if we were trying to guarantee that all harmonic */
  439.         /* oscillators ran in lock-step */
  440.         Template->FrequencyMultiplier = OscillatorGetFrequencyMultiplier(Oscillator)
  441.             / OscillatorGetFrequencyDivisor(Oscillator);
  442.         Template->FrequencyAdder = OscillatorGetFrequencyAdder(Oscillator);
  443.  
  444.         Template->StereoBias = OscillatorGetStereoBias(Oscillator);
  445.         Template->TimeDisplacement = OscillatorGetTimeDisplacement(Oscillator);
  446.         Template->OverallOscillatorLoudness = OscillatorGetOutputLoudness(Oscillator);
  447.  
  448.         if (Stereo)
  449.             {
  450.                 Template->StereoPlayback = eSampleStereo;
  451.             }
  452.          else
  453.             {
  454.                 Template->StereoPlayback = eSampleMono;
  455.             }
  456.         Template->InterpolateThroughTime = TimeInterp;
  457.         Template->InterpolateAcrossWaves = WaveInterp;
  458.         Template->IncludeInFinalOutput = IncludeOscillatorInFinalOutput(Oscillator);
  459.  
  460.         /* these are just references */
  461.         Template->LoudnessEnvelopeTemplate = OscillatorGetLoudnessEnvelope(Oscillator);
  462.         Template->LoudnessLFOTemplate = OscillatorGetLoudnessLFOList(Oscillator);
  463.  
  464.         /* another reference */
  465.         Template->ErrorDaemon = ErrorDaemon;
  466.  
  467.         return Template;
  468.     }
  469.  
  470.  
  471. /* create a new sample state object. */
  472. SampleStateRec*                NewSampleState(SampleTemplateRec* Template,
  473.                                                 float FreqForMultisampling, float Accent1, float Accent2,
  474.                                                 float Accent3, float Accent4, float Loudness, float HurryUp,
  475.                                                 long* PreOriginTimeOut, float StereoPosition,
  476.                                                 float InitialFrequency)
  477.     {
  478.         SampleStateRec*            State;
  479.         long                                MaxPreOrigin;
  480.         long                                OnePreOrigin;
  481.         double                            NaturalFreqTemp;
  482.  
  483.         CheckPtrExistence(Template);
  484.         CheckValidSampleTemplate(Template);
  485.  
  486.         if (SampleStateFreeList != NIL)
  487.             {
  488.                 State = SampleStateFreeList;
  489.                 SampleStateFreeList = SampleStateFreeList->Next;
  490.             }
  491.          else
  492.             {
  493.                 State = (SampleStateRec*)AllocPtrCanFail(sizeof(SampleStateRec),
  494.                     "SampleStateRec");
  495.                 if (State == NIL)
  496.                     {
  497.                      FailurePoint1:
  498.                         return NIL;
  499.                     }
  500.             }
  501.         EXECUTE(State->Next = (SampleStateRec*)0x81818181;)
  502.  
  503.         State->Template = *Template;
  504.  
  505.         MaxPreOrigin = 0;
  506.  
  507.         Double2LongLong(0,State->SamplePosition);
  508.         /* State->SamplePositionDifferential is specified in a separate call */
  509.  
  510.         State->NoteLoudnessScaling = Loudness * Template->OverallOscillatorLoudness;
  511.  
  512.         State->SampleWasDefined = GetMultisampleReferenceSample(
  513.             Template->SampleSourceSelector,FreqForMultisampling,&(State->Data),
  514.             &(State->NumFrames),&(State->NumBits),&(State->NumChannels),&(State->Loop1Start),
  515.             &(State->Loop1End),&(State->Loop2Start),&(State->Loop2End),&(State->Loop3Start),
  516.             &(State->Loop3End),&(State->OriginPoint),&NaturalFreqTemp,&(State->SamplingRate));
  517.  
  518.         if (State->SampleWasDefined && (State->NumFrames > 0))
  519.             {
  520.                 /* copy value over */
  521.                 State->NaturalFrequency = NaturalFreqTemp;
  522.  
  523.                 /* bounds checking */
  524.                 if (State->Loop1Start < 0)
  525.                     {
  526.                         State->Loop1Start = 0;
  527.                     }
  528.                 if (State->Loop1End > State->NumFrames - 1)
  529.                     {
  530.                         State->Loop1End = State->NumFrames - 1;
  531.                     }
  532.                 if (State->Loop1End < State->Loop1Start)
  533.                     {
  534.                         State->Loop1End = State->Loop1Start;
  535.                     }
  536.                 if (State->Loop2Start < 0)
  537.                     {
  538.                         State->Loop2Start = 0;
  539.                     }
  540.                 if (State->Loop2End > State->NumFrames - 1)
  541.                     {
  542.                         State->Loop2End = State->NumFrames - 1;
  543.                     }
  544.                 if (State->Loop2End < State->Loop2Start)
  545.                     {
  546.                         State->Loop2End = State->Loop2Start;
  547.                     }
  548.                 if (State->Loop3Start < 0)
  549.                     {
  550.                         State->Loop3Start = 0;
  551.                     }
  552.                 if (State->Loop3End > State->NumFrames - 1)
  553.                     {
  554.                         State->Loop3End = State->NumFrames - 1;
  555.                     }
  556.                 if (State->Loop3End < State->Loop3Start)
  557.                     {
  558.                         State->Loop3End = State->Loop3Start;
  559.                     }
  560.  
  561.                 /* set the initial state */
  562.                 if (State->Loop1Start != State->Loop1End)
  563.                     {
  564.                         State->LoopState = eRepeatingLoop1;
  565.                         State->CurrentLoopEnd = State->Loop1End;
  566.                         State->CurrentLoopLength = State->Loop1End - State->Loop1Start;
  567.                     }
  568.                 else if (State->Loop2Start != State->Loop2End)
  569.                     {
  570.                         State->LoopState = eRepeatingLoop2;
  571.                         State->CurrentLoopEnd = State->Loop2End;
  572.                         State->CurrentLoopLength = State->Loop2End - State->Loop2Start;
  573.                     }
  574.                 else if (State->Loop3Start != State->Loop3End)
  575.                     {
  576.                         State->LoopState = eRepeatingLoop3;
  577.                         State->CurrentLoopEnd = State->Loop3End;
  578.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  579.                     }
  580.                 else
  581.                     {
  582.                         State->LoopState = eNoLoop;
  583.                         State->CurrentLoopEnd = State->NumFrames;
  584.                         State->CurrentLoopLength = 0;
  585.                     }
  586.  
  587.                 /* compute how much time to wait before starting sample playback.  this */
  588.                 /* is INDEPENDENT of the envelope starting points; the envelope generator setup */
  589.                 /* handles origin alignment on its own. */
  590.                 /* this number will assume the origin starts NOW.  the fixup routine will */
  591.                 /* add some number to this so that the origin is properly determined. */
  592.                 /* if the countdown is still negative, then the sample will sound like it */
  593.                 /* is starting late.  the user can fix this by increasing the scanning gap. */
  594.                 State->PreStartCountdown = - (
  595.                     ((((float)State->OriginPoint / ((InitialFrequency
  596.                         * Template->FrequencyMultiplier + Template->FrequencyAdder)
  597.                         / State->NaturalFrequency)) / State->SamplingRate)
  598.                         - Template->TimeDisplacement)
  599.                     * Template->EnvelopeTicksPerSecond + 0.5);
  600.                 if (- State->PreStartCountdown > MaxPreOrigin)
  601.                     {
  602.                         MaxPreOrigin = - State->PreStartCountdown;
  603.                     }
  604.             }
  605.          else
  606.             {
  607.                 /* no playback */
  608.                 State->LoopState = eSampleFinished;
  609.             }
  610.  
  611.         /* Template->IncludeInFinalOutput: */
  612.         /*   the routine pointer is not used for modulation */
  613.         /* State->SampleWasDefined: */
  614.         /*   if there is no sample defined for the current pitch, then we don't */
  615.         /*   bother generating any data */
  616.         /* State->NumFrames > 0: */
  617.         /*   if there is no data in the sample, then don't access the array */
  618.         if (Template->IncludeInFinalOutput && State->SampleWasDefined && (State->NumFrames > 0))
  619.             {
  620.                 if (Template->StereoPlayback == eSampleStereo) /* this is output stereo */
  621.                     {
  622.                         if (State->NumBits == eSample16bit)
  623.                             {
  624.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  625.                                     {
  626.                                         if (Template->InterpolateThroughTime)
  627.                                             {
  628.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_16BitIn_YesTime;
  629.                                             }
  630.                                          else
  631.                                             {
  632.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_16BitIn_NoTime;
  633.                                             }
  634.                                     }
  635.                                  else /* sample data mono */
  636.                                     {
  637.                                         if (Template->InterpolateThroughTime)
  638.                                             {
  639.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_16BitIn_YesTime;
  640.                                             }
  641.                                          else
  642.                                             {
  643.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_16BitIn_NoTime;
  644.                                             }
  645.                                     }
  646.                             }
  647.                          else /* output 8-bit */
  648.                             {
  649.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  650.                                     {
  651.                                         if (Template->InterpolateThroughTime)
  652.                                             {
  653.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_8BitIn_YesTime;
  654.                                             }
  655.                                          else
  656.                                             {
  657.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_8BitIn_NoTime;
  658.                                             }
  659.                                     }
  660.                                  else /* mono sample data */
  661.                                     {
  662.                                         if (Template->InterpolateThroughTime)
  663.                                             {
  664.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_8BitIn_YesTime;
  665.                                             }
  666.                                          else
  667.                                             {
  668.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_8BitIn_NoTime;
  669.                                             }
  670.                                     }
  671.                             }
  672.                     }
  673.                  else /* output mono */
  674.                     {
  675.                         if (State->NumBits == eSample16bit)
  676.                             {
  677.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  678.                                     {
  679.                                         if (Template->InterpolateThroughTime)
  680.                                             {
  681.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_16BitIn_YesTime;
  682.                                             }
  683.                                          else
  684.                                             {
  685.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_16BitIn_NoTime;
  686.                                             }
  687.                                     }
  688.                                  else /* sample data mono */
  689.                                     {
  690.                                         if (Template->InterpolateThroughTime)
  691.                                             {
  692.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_16BitIn_YesTime;
  693.                                             }
  694.                                          else
  695.                                             {
  696.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_16BitIn_NoTime;
  697.                                             }
  698.                                     }
  699.                             }
  700.                          else /* 8-bit */
  701.                             {
  702.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  703.                                     {
  704.                                         if (Template->InterpolateThroughTime)
  705.                                             {
  706.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_8BitIn_YesTime;
  707.                                             }
  708.                                          else
  709.                                             {
  710.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_8BitIn_NoTime;
  711.                                             }
  712.                                     }
  713.                                  else /* sample data mono */
  714.                                     {
  715.                                         if (Template->InterpolateThroughTime)
  716.                                             {
  717.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_8BitIn_YesTime;
  718.                                             }
  719.                                          else
  720.                                             {
  721.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_8BitIn_NoTime;
  722.                                             }
  723.                                     }
  724.                             }
  725.                     }
  726.             }
  727.          else
  728.             {
  729.                 State->SampleGenSamples = Sample_NoOutput;
  730.             }
  731.  
  732.         /* State->OverallLoudness, State->LeftLoudness, State->RightLoudness */
  733.         /* are determined by the envelope update */
  734.         StereoPosition += Template->StereoBias;
  735.         if (StereoPosition < -1)
  736.             {
  737.                 StereoPosition = -1;
  738.             }
  739.         else if (StereoPosition > 1)
  740.             {
  741.                 StereoPosition = 1;
  742.             }
  743.         State->Panning = Double2FastFixed(StereoPosition);
  744.         State->SampleLoudnessEnvelope = NewEnvelopeStateRecord(
  745.             Template->LoudnessEnvelopeTemplate,Accent1,Accent2,Accent3,Accent4,
  746.             InitialFrequency,1,HurryUp,Template->EnvelopeTicksPerSecond,&OnePreOrigin);
  747.         if (State->SampleLoudnessEnvelope == NIL)
  748.             {
  749.              FailurePoint2:
  750.                 State->Next = SampleStateFreeList;
  751.                 SampleStateFreeList = State;
  752.                 goto FailurePoint1;
  753.             }
  754.         if (OnePreOrigin > MaxPreOrigin)
  755.             {
  756.                 MaxPreOrigin = OnePreOrigin;
  757.             }
  758.         State->LoudnessLFOGenerator = NewLFOGenerator(Template->LoudnessLFOTemplate,
  759.             &OnePreOrigin,Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  760.             Template->EnvelopeTicksPerSecond,1,1,eLFOArithDefault,FreqForMultisampling);
  761.         /* I forgot what to pass in for the last 2 parameters */
  762.         if (State->LoudnessLFOGenerator == NIL)
  763.             {
  764.              FailurePoint3:
  765.                 DisposeEnvelopeStateRecord(State->SampleLoudnessEnvelope);
  766.                 goto FailurePoint2;
  767.             }
  768.         if (OnePreOrigin > MaxPreOrigin)
  769.             {
  770.                 MaxPreOrigin = OnePreOrigin;
  771.             }
  772.  
  773.         *PreOriginTimeOut = MaxPreOrigin;
  774.         return State;
  775.     }
  776.  
  777.  
  778. /* fix up pre-origin time for the sample state object */
  779. void                                    FixUpSampleStatePreOrigin(SampleStateRec* State,
  780.                                                 long ActualPreOrigin)
  781.     {
  782.         CheckPtrExistence(State);
  783.         CheckValidSampleState(State);
  784.  
  785.         EnvelopeStateFixUpInitialDelay(State->SampleLoudnessEnvelope,ActualPreOrigin);
  786.         LFOGeneratorFixEnvelopeOrigins(State->LoudnessLFOGenerator,ActualPreOrigin);
  787.  
  788.         State->PreStartCountdown += ActualPreOrigin;
  789.     }
  790.  
  791.  
  792. /* set a new frequency for a state object.  used for portamento */
  793. /* and modulation of frequency (vibrato) */
  794. void                                    SampleStateNewFrequency(SampleStateRec* State,
  795.                                                 float NewFrequencyHertz)
  796.     {
  797.         CheckPtrExistence(State);
  798.         CheckValidSampleState(State);
  799.  
  800.         Double2LongLong(((NewFrequencyHertz * State->Template.FrequencyMultiplier
  801.             + State->Template.FrequencyAdder) / State->NaturalFrequency)
  802.             / State->Template.FinalOutputSamplingRate
  803.             * State->SamplingRate,State->SamplePositionDifferential);
  804.     }
  805.  
  806.  
  807. /* send a key-up signal to one of the oscillators */
  808. void                                    SampleKeyUpSustain1(SampleStateRec* State)
  809.     {
  810.         CheckPtrExistence(State);
  811.         CheckValidSampleState(State);
  812.  
  813.         LFOGeneratorKeyUpSustain1(State->LoudnessLFOGenerator);
  814.         EnvelopeKeyUpSustain1(State->SampleLoudnessEnvelope);
  815.  
  816.         if (State->LoopState == eRepeatingLoop1)
  817.             {
  818.                 if (State->Loop2Start != State->Loop2End)
  819.                     {
  820.                         State->LoopState = eRepeatingLoop2;
  821.                         State->CurrentLoopEnd = State->Loop2End;
  822.                         State->CurrentLoopLength = State->Loop2End - State->Loop2Start;
  823.                     }
  824.                 else if (State->Loop3Start != State->Loop3End)
  825.                     {
  826.                         State->LoopState = eRepeatingLoop3;
  827.                         State->CurrentLoopEnd = State->Loop3End;
  828.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  829.                     }
  830.                 else
  831.                     {
  832.                         State->LoopState = eNoLoop;
  833.                         State->CurrentLoopEnd = State->NumFrames;
  834.                         State->CurrentLoopLength = 0;
  835.                     }
  836.             }
  837.     }
  838.  
  839.  
  840. /* send a key-up signal to one of the oscillators */
  841. void                                    SampleKeyUpSustain2(SampleStateRec* State)
  842.     {
  843.         CheckPtrExistence(State);
  844.         CheckValidSampleState(State);
  845.  
  846.         LFOGeneratorKeyUpSustain2(State->LoudnessLFOGenerator);
  847.         EnvelopeKeyUpSustain2(State->SampleLoudnessEnvelope);
  848.  
  849.         if (/*(State->LoopState == eRepeatingLoop1)*/
  850.             /*||*/ (State->LoopState == eRepeatingLoop2))
  851.             {
  852.                 if (State->Loop3Start != State->Loop3End)
  853.                     {
  854.                         State->LoopState = eRepeatingLoop3;
  855.                         State->CurrentLoopEnd = State->Loop3End;
  856.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  857.                     }
  858.                 else
  859.                     {
  860.                         State->LoopState = eNoLoop;
  861.                         State->CurrentLoopEnd = State->NumFrames;
  862.                         State->CurrentLoopLength = 0;
  863.                     }
  864.             }
  865.     }
  866.  
  867.  
  868. /* send a key-up signal to one of the oscillators */
  869. void                                    SampleKeyUpSustain3(SampleStateRec* State)
  870.     {
  871.         CheckPtrExistence(State);
  872.         CheckValidSampleState(State);
  873.  
  874.         LFOGeneratorKeyUpSustain3(State->LoudnessLFOGenerator);
  875.         EnvelopeKeyUpSustain3(State->SampleLoudnessEnvelope);
  876.  
  877.         if (/*(State->LoopState == eRepeatingLoop1)*/
  878.             /*|| (State->LoopState == eRepeatingLoop2)*/
  879.             /*||*/ (State->LoopState == eRepeatingLoop3))
  880.             {
  881.                 State->LoopState = eNoLoop;
  882.                 State->CurrentLoopEnd = State->NumFrames;
  883.                 State->CurrentLoopLength = 0;
  884.             }
  885.     }
  886.  
  887.  
  888. /* restart a sample oscillator.  this is used for tie continuations */
  889. void                                    RestartSampleState(SampleStateRec* State,
  890.                                                 float NewFreqMultisampling, float NewAccent1, float NewAccent2,
  891.                                                 float NewAccent3, float NewAccent4, float NewLoudness,
  892.                                                 float NewHurryUp, MyBoolean RetriggerEnvelopes,
  893.                                                 float NewStereoPosition, float NewInitialFrequency)
  894.     {
  895.         CheckPtrExistence(State);
  896.         CheckValidSampleState(State);
  897.  
  898.         NewStereoPosition += State->Template.StereoBias;
  899.         if (NewStereoPosition < -1)
  900.             {
  901.                 NewStereoPosition = -1;
  902.             }
  903.         else if (NewStereoPosition > 1)
  904.             {
  905.                 NewStereoPosition = 1;
  906.             }
  907.         State->Panning = Double2FastFixed(NewStereoPosition);
  908.  
  909.         State->NoteLoudnessScaling = NewLoudness * State->Template.OverallOscillatorLoudness;
  910.  
  911.         EnvelopeRetriggerFromOrigin(State->SampleLoudnessEnvelope,NewAccent1,NewAccent2,
  912.             NewAccent3,NewAccent4,NewInitialFrequency,1,NewHurryUp,
  913.             State->Template.EnvelopeTicksPerSecond,RetriggerEnvelopes);
  914.         LFOGeneratorRetriggerFromOrigin(State->LoudnessLFOGenerator,NewAccent1,
  915.             NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,NewHurryUp,
  916.             State->Template.EnvelopeTicksPerSecond,1,1,RetriggerEnvelopes);
  917.     }
  918.  
  919.  
  920. /* generate a sequence of samples (called for each envelope clock) */
  921. void                                    SampleGenSamples(SampleStateRec* State,
  922.                                                 long SampleCount, largefixedsigned* RawBuffer)
  923.     {
  924.         CheckPtrExistence(State);
  925.         CheckValidSampleState(State);
  926.  
  927.         if (State->PreStartCountdown > 0)
  928.             {
  929.                 return;
  930.             }
  931.         if (State->LoopState != eSampleFinished)
  932.             {
  933.                 (*State->SampleGenSamples)(State,SampleCount,RawBuffer);
  934.             }
  935.     }
  936.  
  937.  
  938. /* find out if the sample oscillator has finished */
  939. MyBoolean                            SampleIsItFinished(SampleStateRec* State)
  940.     {
  941.         CheckPtrExistence(State);
  942.         CheckValidSampleState(State);
  943.  
  944.         /* we are finished when one of the following conditions is met: */
  945.         /*  - output volume is zero AND loudness envelope is finished */
  946.         /*  - we have run off the end of the sample */
  947.         /*  - we are not generating any signal */
  948.         if (!State->SampleWasDefined)
  949.             {
  950.                 return True;
  951.             }
  952.         if (State->LoopState == eSampleFinished)
  953.             {
  954.                 return True;
  955.             }
  956.         if (IsEnvelopeAtEnd(State->SampleLoudnessEnvelope))
  957.             {
  958.                 if (State->Template.StereoPlayback == eSampleStereo)
  959.                     {
  960.                         if ((State->LeftLoudness == 0) && (State->RightLoudness == 0))
  961.                             {
  962.                                 return True;
  963.                             }
  964.                     }
  965.                  else
  966.                     {
  967.                         if (State->OverallLoudness == 0)
  968.                             {
  969.                                 return True;
  970.                             }
  971.                     }
  972.             }
  973.  
  974.         return False;
  975.     }
  976.  
  977.  
  978. /* generate a single sample (called for modulation chains) */
  979. /* OutputPlace should have 1 entry for mono output or 2 entries for stereo output */
  980. float                                    SampleGenOneSample(SampleStateRec* State,
  981.                                                 ModulationTypes* PhaseGenModulateHow,
  982.                                                 float* PhaseGenModulationScaling,
  983.                                                 float* PhaseGenModulationOrigin,
  984.                                                 float* PhaseGenOldValues,
  985.                                                 long* PhaseGenIndirectionTable,
  986.                                                 long NumberOfPhaseGenModulators,
  987.                                                 ModulationTypes* OutputModulateHow,
  988.                                                 float* OutputModulationScaling,
  989.                                                 float* OutputModulationOrigin,
  990.                                                 float* OutputOldValues,
  991.                                                 long* OutputIndirectionTable,
  992.                                                 long NumberOfOutputModulators,
  993.                                                 largefixedsigned* OutputPlace)
  994.     {
  995.         float                                ReturnValue;
  996.         LongLongRec                    FrameIndex;
  997.         signed long                    FinalLeft; /* 16-bit value */
  998.         signed long                    FinalRight; /* 16-bit value */
  999.  
  1000.         CheckPtrExistence(State);
  1001.         CheckValidSampleState(State);
  1002.  
  1003.         if (!State->SampleWasDefined || (State->LoopState == eSampleFinished)
  1004.             || (State->NumFrames == 0) || (State->PreStartCountdown > 0))
  1005.             {
  1006.                 /* modulate against zero */
  1007.                 if (State->Template.StereoPlayback == eSampleStereo)
  1008.                     {
  1009.                         OutputPlace[0] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1010.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1011.                             OutputIndirectionTable,NumberOfOutputModulators));
  1012.                         OutputPlace[1] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1013.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1014.                             OutputIndirectionTable,NumberOfOutputModulators));
  1015.                     }
  1016.                  else
  1017.                     {
  1018.                         OutputPlace[0] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1019.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1020.                             OutputIndirectionTable,NumberOfOutputModulators));
  1021.                     }
  1022.                 return 0;
  1023.             }
  1024.  
  1025.         /* generate the sample position */
  1026.         /* we need to normalize the sample position to make modulation characteristics */
  1027.         /* independent on sampling rate.  this is done by normalizing the sample so that */
  1028.         /* a displacement of 1 corresponds to 1 second of evaluation time. */
  1029.         Double2LongLong(ApplyModulation(LongLong2Double(State->SamplePosition)
  1030.             / State->SamplingRate,PhaseGenModulateHow,PhaseGenModulationScaling,
  1031.             PhaseGenModulationOrigin,PhaseGenOldValues,PhaseGenIndirectionTable,
  1032.             NumberOfPhaseGenModulators) * State->SamplingRate,FrameIndex);
  1033.         /* ugh, phase modulation of a sample is nasty. */
  1034.         if (LongLongHighHalf(FrameIndex) < 0)
  1035.             {
  1036.                 LongLongSetHighHalf(FrameIndex,0);
  1037.             }
  1038.         if (LongLongHighHalf(FrameIndex) > State->NumFrames - 1)
  1039.             {
  1040.                 LongLongSetHighHalf(FrameIndex,State->NumFrames - 1);
  1041.             }
  1042.  
  1043.         if (State->NumChannels == eSampleStereo)
  1044.             {
  1045.                 /* stereo sample */
  1046.                 if (State->NumBits == eSample16bit)
  1047.                     {
  1048.                         /* stereo sample, 16 bit */
  1049.                         if (State->Template.InterpolateThroughTime)
  1050.                             {
  1051.                                 signed short*                SampleData;
  1052.                                 FastFixedType                LeftWeight;
  1053.                                 long                                ArraySubscript;
  1054.                                 signed long                    LeftValue;
  1055.                                 signed long                    RightValue;
  1056.  
  1057.                                 /* stereo sample, 16 bit, interpolate */
  1058.                                 SampleData = (signed short*)State->Data;
  1059.                                 /* L+F(R-L) */
  1060.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1061.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1062.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1063.                                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1064.                                 LeftValue = SampleData[2 * (ArraySubscript + 0)];
  1065.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1066.                                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1067.                                 RightValue = SampleData[2 * (ArraySubscript + 1)];
  1068.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1069.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1070.                                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1071.                                 LeftValue = SampleData[2 * (ArraySubscript + 0) + 1];
  1072.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1073.                                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1074.                                 RightValue = SampleData[2 * (ArraySubscript + 1) + 1];
  1075.                                 FinalRight = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1076.                             }
  1077.                          else
  1078.                             {
  1079.                                 signed short*                SampleData;
  1080.  
  1081.                                 /* stereo output, stereo sample, 16 bit, truncate */
  1082.                                 SampleData = (signed short*)State->Data;
  1083.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1084.                                     FrameIndex) + 0]),sizeof(SampleData[2
  1085.                                     * LongLongHighHalf(FrameIndex) + 0]));
  1086.                                 FinalLeft = SampleData[2 * LongLongHighHalf(FrameIndex) + 0];
  1087.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1088.                                     FrameIndex) + 1]),sizeof(SampleData[2
  1089.                                     * LongLongHighHalf(FrameIndex) + 1]));
  1090.                                 FinalRight = SampleData[2 * LongLongHighHalf(FrameIndex) + 1];
  1091.                             }
  1092.                     }
  1093.                  else
  1094.                     {
  1095.                         /* stereo sample, 8 bit */
  1096.                         if (State->Template.InterpolateThroughTime)
  1097.                             {
  1098.                                 signed char*                SampleData;
  1099.                                 FastFixedType                LeftWeight;
  1100.                                 long                                ArraySubscript;
  1101.                                 signed long                    LeftValue;
  1102.                                 signed long                    RightValue;
  1103.  
  1104.                                 /* stereo sample, 8 bit, interpolate */
  1105.                                 SampleData = (signed char*)State->Data;
  1106.                                 /* L+F(R-L) */
  1107.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1108.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1109.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1110.                                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1111.                                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0)]) << 8; /* convert to 16-bit */
  1112.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1113.                                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1114.                                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1)]) << 8; /* to 16-bit */
  1115.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1116.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1117.                                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1118.                                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0) + 1]) << 8; /* convert to 16-bit */
  1119.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1120.                                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1121.                                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 8; /* to 16-bit */
  1122.                                 FinalRight = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1123.                             }
  1124.                          else
  1125.                             {
  1126.                                 signed char*                SampleData;
  1127.  
  1128.                                 /* stereo sample, 8 bit, truncate */
  1129.                                 SampleData = (signed char*)State->Data;
  1130.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1131.                                     FrameIndex) + 0]),sizeof(SampleData[2
  1132.                                     * LongLongHighHalf(FrameIndex) + 0]));
  1133.                                 FinalLeft = SampleData[2 * LongLongHighHalf(FrameIndex) + 0];
  1134.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1135.                                     FrameIndex) + 1]),sizeof(SampleData[2
  1136.                                     * LongLongHighHalf(FrameIndex) + 1]));
  1137.                                 FinalRight = SampleData[2 * LongLongHighHalf(FrameIndex) + 1];
  1138.                             }
  1139.                     }
  1140.             }
  1141.          else
  1142.             {
  1143.                 /* mono sample */
  1144.                 if (State->NumBits == eSample16bit)
  1145.                     {
  1146.                         /* mono sample, 16 bit */
  1147.                         if (State->Template.InterpolateThroughTime)
  1148.                             {
  1149.                                 signed short*                SampleData;
  1150.                                 FastFixedType                LeftWeight;
  1151.                                 long                                ArraySubscript;
  1152.                                 signed long                    LeftValue;
  1153.                                 signed long                    RightValue;
  1154.  
  1155.                                 /* mono sample, 16 bit, interpolate */
  1156.                                 SampleData = (signed short*)State->Data;
  1157.                                 /* L+F(R-L) */
  1158.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1159.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1160.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1161.                                     sizeof(SampleData[ArraySubscript]));
  1162.                                 LeftValue = SampleData[ArraySubscript];
  1163.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1164.                                     sizeof(SampleData[ArraySubscript + 1]));
  1165.                                 RightValue = SampleData[ArraySubscript + 1];
  1166.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1167.                                 FinalRight = FinalLeft;
  1168.                             }
  1169.                          else
  1170.                             {
  1171.                                 signed short*                SampleData;
  1172.  
  1173.                                 /* mono sample, 16 bit, truncate */
  1174.                                 SampleData = (signed short*)State->Data;
  1175.                                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(
  1176.                                     FrameIndex)]),sizeof(SampleData[LongLongHighHalf(
  1177.                                     FrameIndex)]));
  1178.                                 FinalLeft = SampleData[LongLongHighHalf(FrameIndex)];
  1179.                                 FinalRight = FinalLeft;
  1180.                             }
  1181.                     }
  1182.                  else
  1183.                     {
  1184.                         /* mono sample, 8 bit */
  1185.                         if (State->Template.InterpolateThroughTime)
  1186.                             {
  1187.                                 signed char*                SampleData;
  1188.                                 FastFixedType                LeftWeight;
  1189.                                 long                                ArraySubscript;
  1190.                                 signed long                    LeftValue;
  1191.                                 signed long                    RightValue;
  1192.  
  1193.                                 /* mono sample, 8 bit, interpolate */
  1194.                                 SampleData = (signed char*)State->Data;
  1195.                                 /* L+F(R-L) */
  1196.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1197.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1198.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1199.                                     sizeof(SampleData[ArraySubscript]));
  1200.                                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1201.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1202.                                     sizeof(SampleData[ArraySubscript + 1]));
  1203.                                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1204.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1205.                                 FinalRight = FinalLeft;
  1206.                             }
  1207.                          else
  1208.                             {
  1209.                                 signed char*                SampleData;
  1210.  
  1211.                                 /* stereo output, mono sample, 8 bit, truncate */
  1212.                                 SampleData = (signed char*)State->Data;
  1213.                                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(
  1214.                                     FrameIndex)]),sizeof(SampleData[LongLongHighHalf(
  1215.                                         FrameIndex)]));
  1216.                                 FinalLeft = SampleData[LongLongHighHalf(FrameIndex)];
  1217.                                 FinalRight = FinalLeft;
  1218.                             }
  1219.                     }
  1220.             }
  1221.  
  1222.         if (State->Template.StereoPlayback == eSampleStereo)
  1223.             {
  1224.                 ReturnValue = (((float)((FinalLeft + FinalRight) / 2)) / MAX16BIT)
  1225.                     * ((FastFixed2Float(State->LeftLoudness)
  1226.                     + FastFixed2Float(State->RightLoudness)) / 2);
  1227.                 if (State->Template.IncludeInFinalOutput)
  1228.                     {
  1229.                         OutputPlace[0] += double2largefixed(ApplyModulation(largefixed2single(
  1230.                             FastFixedTimes16BitTo24Bit((signed long)(State->LeftLoudness
  1231.                             * State->NoteLoudnessScaling),FinalLeft)),OutputModulateHow,
  1232.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1233.                             OutputIndirectionTable,NumberOfOutputModulators));;
  1234.                         OutputPlace[1] += double2largefixed(ApplyModulation(largefixed2single(
  1235.                             FastFixedTimes16BitTo24Bit((signed long)(State->RightLoudness
  1236.                             * State->NoteLoudnessScaling),FinalRight)),OutputModulateHow,
  1237.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1238.                             OutputIndirectionTable,NumberOfOutputModulators));
  1239.                     }
  1240.             }
  1241.          else
  1242.             {
  1243.                 ReturnValue = (((float)((FinalLeft + FinalRight) / 2)) / MAX16BIT)
  1244.                     * FastFixed2Float(State->OverallLoudness);
  1245.                 if (State->Template.IncludeInFinalOutput)
  1246.                     {
  1247.                         OutputPlace[0] += double2largefixed(ApplyModulation(largefixed2single(
  1248.                             FastFixedTimes16BitTo24Bit((signed long)(State->OverallLoudness
  1249.                             * State->NoteLoudnessScaling),((FinalLeft + FinalRight) / 2))),
  1250.                             OutputModulateHow,OutputModulationScaling,OutputModulationOrigin,
  1251.                             OutputOldValues,OutputIndirectionTable,NumberOfOutputModulators));
  1252.                     }
  1253.             }
  1254.  
  1255.         LongLongAdd(&State->SamplePosition,&State->SamplePositionDifferential);
  1256.      CheapDoLoop:
  1257.         if (LongLongHighHalf(State->SamplePosition) >= State->CurrentLoopEnd)
  1258.             {
  1259.                 if (State->LoopState != eNoLoop)
  1260.                     {
  1261.                         /* handle loop */
  1262.                         LongLongSetHighHalf(State->SamplePosition,LongLongHighHalf(
  1263.                             State->SamplePosition) - State->CurrentLoopLength);
  1264.                         goto CheapDoLoop;
  1265.                     }
  1266.                  else
  1267.                     {
  1268.                         /* end of sample -- terminate */
  1269.                         State->LoopState = eSampleFinished;
  1270.                         goto BreakLoopPoint;
  1271.                     }
  1272.             }
  1273.      BreakLoopPoint:
  1274.         ;
  1275.  
  1276.         return ReturnValue;
  1277.     }
  1278.  
  1279.  
  1280. static void                        Sample_MonoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  1281.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1282.     {
  1283.         LongLongRec                    LocalSamplePosition;
  1284.         LongLongRec                    LocalSamplePositionDifferential;
  1285.         long                                LocalCurrentLoopEnd;
  1286.         FastFixedType                LocalOverallLoudness;
  1287.         signed char*                SampleData;
  1288.  
  1289.         LocalOverallLoudness = State->OverallLoudness;
  1290.         LocalSamplePosition = State->SamplePosition;
  1291.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1292.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1293.         SampleData = (signed char*)State->Data;
  1294.  
  1295.         while (SampleCount > 0)
  1296.             {
  1297.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1298.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1299.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalOverallLoudness,
  1300.                     SampleData[LongLongHighHalf(LocalSamplePosition)]);
  1301.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1302.              CheapDoLoop:
  1303.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1304.                     {
  1305.                         if (State->LoopState != eNoLoop)
  1306.                             {
  1307.                                 /* handle loop */
  1308.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1309.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1310.                                 goto CheapDoLoop;
  1311.                             }
  1312.                          else
  1313.                             {
  1314.                                 /* end of sample -- terminate */
  1315.                                 State->LoopState = eSampleFinished;
  1316.                                 goto BreakLoopPoint;
  1317.                             }
  1318.                     }
  1319.                 SampleCount -= 1;
  1320.             }
  1321.      BreakLoopPoint:
  1322.         ;
  1323.  
  1324.         State->SamplePosition = LocalSamplePosition;
  1325.     }
  1326.  
  1327.  
  1328. static void                        Sample_StereoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  1329.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1330.     {
  1331.         LongLongRec                    LocalSamplePosition;
  1332.         LongLongRec                    LocalSamplePositionDifferential;
  1333.         long                                LocalCurrentLoopEnd;
  1334.         FastFixedType                LocalLeftLoudness;
  1335.         FastFixedType                LocalRightLoudness;
  1336.         signed char*                SampleData;
  1337.  
  1338.         LocalLeftLoudness = State->LeftLoudness;
  1339.         LocalRightLoudness = State->RightLoudness;
  1340.         LocalSamplePosition = State->SamplePosition;
  1341.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1342.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1343.         SampleData = (signed char*)State->Data;
  1344.  
  1345.         while (SampleCount > 0)
  1346.             {
  1347.                 signed long                    SamplePoint;
  1348.  
  1349.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1350.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1351.                 SamplePoint = SampleData[LongLongHighHalf(LocalSamplePosition)];
  1352.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalLeftLoudness,SamplePoint);
  1353.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalRightLoudness,SamplePoint);
  1354.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1355.              CheapDoLoop:
  1356.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1357.                     {
  1358.                         if (State->LoopState != eNoLoop)
  1359.                             {
  1360.                                 /* handle loop */
  1361.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1362.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1363.                                 goto CheapDoLoop;
  1364.                             }
  1365.                          else
  1366.                             {
  1367.                                 /* end of sample -- terminate */
  1368.                                 State->LoopState = eSampleFinished;
  1369.                                 goto BreakLoopPoint;
  1370.                             }
  1371.                     }
  1372.                 SampleCount -= 1;
  1373.             }
  1374.      BreakLoopPoint:
  1375.         ;
  1376.  
  1377.         State->SamplePosition = LocalSamplePosition;
  1378.     }
  1379.  
  1380.  
  1381. static void                        Sample_MonoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  1382.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1383.     {
  1384.         LongLongRec                    LocalSamplePosition;
  1385.         LongLongRec                    LocalSamplePositionDifferential;
  1386.         long                                LocalCurrentLoopEnd;
  1387.         FastFixedType                LocalOverallLoudness;
  1388.         signed char*                SampleData;
  1389.  
  1390.         LocalOverallLoudness = State->OverallLoudness;
  1391.         LocalSamplePosition = State->SamplePosition;
  1392.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1393.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1394.         SampleData = (signed char*)State->Data;
  1395.  
  1396.         while (SampleCount > 0)
  1397.             {
  1398.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1399.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1400.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1401.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1402.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalOverallLoudness,
  1403.                     ((signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]
  1404.                     + (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]) >> 1);
  1405.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1406.              CheapDoLoop:
  1407.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1408.                     {
  1409.                         if (State->LoopState != eNoLoop)
  1410.                             {
  1411.                                 /* handle loop */
  1412.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1413.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1414.                                 goto CheapDoLoop;
  1415.                             }
  1416.                          else
  1417.                             {
  1418.                                 /* end of sample -- terminate */
  1419.                                 State->LoopState = eSampleFinished;
  1420.                                 goto BreakLoopPoint;
  1421.                             }
  1422.                     }
  1423.                 SampleCount -= 1;
  1424.             }
  1425.      BreakLoopPoint:
  1426.         ;
  1427.  
  1428.         State->SamplePosition = LocalSamplePosition;
  1429.     }
  1430.  
  1431.  
  1432. static void                        Sample_StereoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  1433.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1434.     {
  1435.         LongLongRec                    LocalSamplePosition;
  1436.         LongLongRec                    LocalSamplePositionDifferential;
  1437.         long                                LocalCurrentLoopEnd;
  1438.         FastFixedType                LocalLeftLoudness;
  1439.         FastFixedType                LocalRightLoudness;
  1440.         signed char*                SampleData;
  1441.  
  1442.         LocalLeftLoudness = State->LeftLoudness;
  1443.         LocalRightLoudness = State->RightLoudness;
  1444.         LocalSamplePosition = State->SamplePosition;
  1445.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1446.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1447.         SampleData = (signed char*)State->Data;
  1448.  
  1449.         while (SampleCount > 0)
  1450.             {
  1451.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1452.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1453.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalLeftLoudness,
  1454.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]);
  1455.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1456.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1457.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalRightLoudness,
  1458.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]);
  1459.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1460.              CheapDoLoop:
  1461.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1462.                     {
  1463.                         if (State->LoopState != eNoLoop)
  1464.                             {
  1465.                                 /* handle loop */
  1466.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1467.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1468.                                 goto CheapDoLoop;
  1469.                             }
  1470.                          else
  1471.                             {
  1472.                                 /* end of sample -- terminate */
  1473.                                 State->LoopState = eSampleFinished;
  1474.                                 goto BreakLoopPoint;
  1475.                             }
  1476.                     }
  1477.                 SampleCount -= 1;
  1478.             }
  1479.      BreakLoopPoint:
  1480.         ;
  1481.  
  1482.         State->SamplePosition = LocalSamplePosition;
  1483.     }
  1484.  
  1485.  
  1486. static void                        Sample_MonoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  1487.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1488.     {
  1489.         LongLongRec                    LocalSamplePosition;
  1490.         LongLongRec                    LocalSamplePositionDifferential;
  1491.         long                                LocalCurrentLoopEnd;
  1492.         FastFixedType                LocalOverallLoudness;
  1493.         signed short*                SampleData;
  1494.  
  1495.         LocalOverallLoudness = State->OverallLoudness;
  1496.         LocalSamplePosition = State->SamplePosition;
  1497.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1498.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1499.         SampleData = (signed short*)State->Data;
  1500.  
  1501.         while (SampleCount > 0)
  1502.             {
  1503.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1504.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1505.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,
  1506.                     SampleData[LongLongHighHalf(LocalSamplePosition)]);
  1507.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1508.              CheapDoLoop:
  1509.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1510.                     {
  1511.                         if (State->LoopState != eNoLoop)
  1512.                             {
  1513.                                 /* handle loop */
  1514.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1515.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1516.                                 goto CheapDoLoop;
  1517.                             }
  1518.                          else
  1519.                             {
  1520.                                 /* end of sample -- terminate */
  1521.                                 State->LoopState = eSampleFinished;
  1522.                                 goto BreakLoopPoint;
  1523.                             }
  1524.                     }
  1525.                 SampleCount -= 1;
  1526.             }
  1527.      BreakLoopPoint:
  1528.         ;
  1529.  
  1530.         State->SamplePosition = LocalSamplePosition;
  1531.     }
  1532.  
  1533.  
  1534. static void                        Sample_StereoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  1535.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1536.     {
  1537.         LongLongRec                    LocalSamplePosition;
  1538.         LongLongRec                    LocalSamplePositionDifferential;
  1539.         long                                LocalCurrentLoopEnd;
  1540.         FastFixedType                LocalLeftLoudness;
  1541.         FastFixedType                LocalRightLoudness;
  1542.         signed short*                SampleData;
  1543.  
  1544.         LocalLeftLoudness = State->LeftLoudness;
  1545.         LocalRightLoudness = State->RightLoudness;
  1546.         LocalSamplePosition = State->SamplePosition;
  1547.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1548.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1549.         SampleData = (signed short*)State->Data;
  1550.  
  1551.         while (SampleCount > 0)
  1552.             {
  1553.                 signed long                    SamplePoint;
  1554.  
  1555.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1556.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1557.                 SamplePoint = SampleData[LongLongHighHalf(LocalSamplePosition)];
  1558.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,SamplePoint);
  1559.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,SamplePoint);
  1560.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1561.              CheapDoLoop:
  1562.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1563.                     {
  1564.                         if (State->LoopState != eNoLoop)
  1565.                             {
  1566.                                 /* handle loop */
  1567.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1568.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1569.                                 goto CheapDoLoop;
  1570.                             }
  1571.                          else
  1572.                             {
  1573.                                 /* end of sample -- terminate */
  1574.                                 State->LoopState = eSampleFinished;
  1575.                                 goto BreakLoopPoint;
  1576.                             }
  1577.                     }
  1578.                 SampleCount -= 1;
  1579.             }
  1580.      BreakLoopPoint:
  1581.         ;
  1582.  
  1583.         State->SamplePosition = LocalSamplePosition;
  1584.     }
  1585.  
  1586.  
  1587. static void                        Sample_MonoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  1588.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1589.     {
  1590.         LongLongRec                    LocalSamplePosition;
  1591.         LongLongRec                    LocalSamplePositionDifferential;
  1592.         long                                LocalCurrentLoopEnd;
  1593.         FastFixedType                LocalOverallLoudness;
  1594.         signed short*                SampleData;
  1595.  
  1596.         LocalOverallLoudness = State->OverallLoudness;
  1597.         LocalSamplePosition = State->SamplePosition;
  1598.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1599.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1600.         SampleData = (signed short*)State->Data;
  1601.  
  1602.         while (SampleCount > 0)
  1603.             {
  1604.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1605.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1606.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1607.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1608.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,
  1609.                     ((signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]
  1610.                     + (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]) >> 1);
  1611.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1612.              CheapDoLoop:
  1613.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1614.                     {
  1615.                         if (State->LoopState != eNoLoop)
  1616.                             {
  1617.                                 /* handle loop */
  1618.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1619.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1620.                                 goto CheapDoLoop;
  1621.                             }
  1622.                          else
  1623.                             {
  1624.                                 /* end of sample -- terminate */
  1625.                                 State->LoopState = eSampleFinished;
  1626.                                 goto BreakLoopPoint;
  1627.                             }
  1628.                     }
  1629.                 SampleCount -= 1;
  1630.             }
  1631.      BreakLoopPoint:
  1632.         ;
  1633.  
  1634.         State->SamplePosition = LocalSamplePosition;
  1635.     }
  1636.  
  1637.  
  1638. static void                        Sample_StereoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  1639.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1640.     {
  1641.         LongLongRec                    LocalSamplePosition;
  1642.         LongLongRec                    LocalSamplePositionDifferential;
  1643.         long                                LocalCurrentLoopEnd;
  1644.         FastFixedType                LocalLeftLoudness;
  1645.         FastFixedType                LocalRightLoudness;
  1646.         signed short*                SampleData;
  1647.  
  1648.         LocalLeftLoudness = State->LeftLoudness;
  1649.         LocalRightLoudness = State->RightLoudness;
  1650.         LocalSamplePosition = State->SamplePosition;
  1651.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1652.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1653.         SampleData = (signed short*)State->Data;
  1654.  
  1655.         while (SampleCount > 0)
  1656.             {
  1657.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1658.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1659.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,
  1660.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]);
  1661.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1662.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1663.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,
  1664.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]);
  1665.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1666.              CheapDoLoop:
  1667.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1668.                     {
  1669.                         if (State->LoopState != eNoLoop)
  1670.                             {
  1671.                                 /* handle loop */
  1672.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1673.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1674.                                 goto CheapDoLoop;
  1675.                             }
  1676.                          else
  1677.                             {
  1678.                                 /* end of sample -- terminate */
  1679.                                 State->LoopState = eSampleFinished;
  1680.                                 goto BreakLoopPoint;
  1681.                             }
  1682.                     }
  1683.                 SampleCount -= 1;
  1684.             }
  1685.      BreakLoopPoint:
  1686.         ;
  1687.  
  1688.         State->SamplePosition = LocalSamplePosition;
  1689.     }
  1690.  
  1691.  
  1692. static void                        Sample_MonoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  1693.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1694.     {
  1695.         LongLongRec                    LocalSamplePosition;
  1696.         LongLongRec                    LocalSamplePositionDifferential;
  1697.         long                                LocalCurrentLoopEnd;
  1698.         FastFixedType                LocalOverallLoudness;
  1699.         signed char*                SampleData;
  1700.  
  1701.         LocalOverallLoudness = State->OverallLoudness;
  1702.         LocalSamplePosition = State->SamplePosition;
  1703.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1704.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1705.         SampleData = (signed char*)State->Data;
  1706.  
  1707.         while (SampleCount > 0)
  1708.             {
  1709.                 FastFixedType                LeftWeight;
  1710.                 long                                ArraySubscript;
  1711.                 signed long                    LeftValue;
  1712.                 signed long                    RightValue;
  1713.  
  1714.                 /* L+F(R-L) */
  1715.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1716.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1717.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1718.                     sizeof(SampleData[ArraySubscript]));
  1719.                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1720.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1721.                     sizeof(SampleData[ArraySubscript + 1]));
  1722.                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1723.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1724.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1725.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1726.              CheapDoLoop:
  1727.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1728.                     {
  1729.                         if (State->LoopState != eNoLoop)
  1730.                             {
  1731.                                 /* handle loop */
  1732.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1733.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1734.                                 goto CheapDoLoop;
  1735.                             }
  1736.                          else
  1737.                             {
  1738.                                 /* end of sample -- terminate */
  1739.                                 State->LoopState = eSampleFinished;
  1740.                                 goto BreakLoopPoint;
  1741.                             }
  1742.                     }
  1743.                 SampleCount -= 1;
  1744.             }
  1745.      BreakLoopPoint:
  1746.         ;
  1747.  
  1748.         State->SamplePosition = LocalSamplePosition;
  1749.     }
  1750.  
  1751.  
  1752. static void                        Sample_StereoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  1753.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1754.     {
  1755.         LongLongRec                    LocalSamplePosition;
  1756.         LongLongRec                    LocalSamplePositionDifferential;
  1757.         long                                LocalCurrentLoopEnd;
  1758.         FastFixedType                LocalLeftLoudness;
  1759.         FastFixedType                LocalRightLoudness;
  1760.         signed char*                SampleData;
  1761.  
  1762.         LocalLeftLoudness = State->LeftLoudness;
  1763.         LocalRightLoudness = State->RightLoudness;
  1764.         LocalSamplePosition = State->SamplePosition;
  1765.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1766.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1767.         SampleData = (signed char*)State->Data;
  1768.  
  1769.         while (SampleCount > 0)
  1770.             {
  1771.                 FastFixedType                LeftWeight;
  1772.                 long                                ArraySubscript;
  1773.                 signed long                    LeftValue;
  1774.                 signed long                    RightValue;
  1775.                 signed long                    CombinedValue;
  1776.  
  1777.                 /* L+F(R-L) */
  1778.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1779.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1780.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1781.                     sizeof(SampleData[ArraySubscript]));
  1782.                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1783.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1784.                     sizeof(SampleData[ArraySubscript + 1]));
  1785.                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1786.                 CombinedValue = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1787.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,CombinedValue);
  1788.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,CombinedValue);
  1789.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1790.              CheapDoLoop:
  1791.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1792.                     {
  1793.                         if (State->LoopState != eNoLoop)
  1794.                             {
  1795.                                 /* handle loop */
  1796.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1797.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1798.                                 goto CheapDoLoop;
  1799.                             }
  1800.                          else
  1801.                             {
  1802.                                 /* end of sample -- terminate */
  1803.                                 State->LoopState = eSampleFinished;
  1804.                                 goto BreakLoopPoint;
  1805.                             }
  1806.                     }
  1807.                 SampleCount -= 1;
  1808.             }
  1809.      BreakLoopPoint:
  1810.         ;
  1811.  
  1812.         State->SamplePosition = LocalSamplePosition;
  1813.     }
  1814.  
  1815.  
  1816. static void                        Sample_MonoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  1817.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1818.     {
  1819.         LongLongRec                    LocalSamplePosition;
  1820.         LongLongRec                    LocalSamplePositionDifferential;
  1821.         long                                LocalCurrentLoopEnd;
  1822.         FastFixedType                LocalOverallLoudness;
  1823.         signed char*                SampleData;
  1824.  
  1825.         LocalOverallLoudness = State->OverallLoudness;
  1826.         LocalSamplePosition = State->SamplePosition;
  1827.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1828.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1829.         SampleData = (signed char*)State->Data;
  1830.  
  1831.         while (SampleCount > 0)
  1832.             {
  1833.                 FastFixedType                LeftWeight;
  1834.                 long                                ArraySubscript;
  1835.                 signed long                    LeftValue;
  1836.                 signed long                    RightValue;
  1837.  
  1838.                 /* L+F(R-L) */
  1839.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1840.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1841.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 0]),
  1842.                     sizeof(SampleData[2 * ArraySubscript + 0]));
  1843.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 1]),
  1844.                     sizeof(SampleData[2 * ArraySubscript + 1]));
  1845.                 LeftValue = ((signed long)SampleData[2 * ArraySubscript + 0]
  1846.                     + (signed long)SampleData[2 * ArraySubscript + 1]) << 7; /* convert to 16-bit */
  1847.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 0]),
  1848.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 0]));
  1849.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1850.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1851.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 0]
  1852.                     + (signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 7; /* to 16-bit */
  1853.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1854.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1855.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1856.              CheapDoLoop:
  1857.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1858.                     {
  1859.                         if (State->LoopState != eNoLoop)
  1860.                             {
  1861.                                 /* handle loop */
  1862.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1863.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1864.                                 goto CheapDoLoop;
  1865.                             }
  1866.                          else
  1867.                             {
  1868.                                 /* end of sample -- terminate */
  1869.                                 State->LoopState = eSampleFinished;
  1870.                                 goto BreakLoopPoint;
  1871.                             }
  1872.                     }
  1873.                 SampleCount -= 1;
  1874.             }
  1875.      BreakLoopPoint:
  1876.         ;
  1877.  
  1878.         State->SamplePosition = LocalSamplePosition;
  1879.     }
  1880.  
  1881.  
  1882. static void                        Sample_StereoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  1883.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1884.     {
  1885.         LongLongRec                    LocalSamplePosition;
  1886.         LongLongRec                    LocalSamplePositionDifferential;
  1887.         long                                LocalCurrentLoopEnd;
  1888.         FastFixedType                LocalLeftLoudness;
  1889.         FastFixedType                LocalRightLoudness;
  1890.         signed char*                SampleData;
  1891.  
  1892.         LocalLeftLoudness = State->LeftLoudness;
  1893.         LocalRightLoudness = State->RightLoudness;
  1894.         LocalSamplePosition = State->SamplePosition;
  1895.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1896.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1897.         SampleData = (signed char*)State->Data;
  1898.  
  1899.         while (SampleCount > 0)
  1900.             {
  1901.                 FastFixedType                LeftWeight;
  1902.                 long                                ArraySubscript;
  1903.                 signed long                    LeftValue;
  1904.                 signed long                    RightValue;
  1905.  
  1906.                 /* L+F(R-L) */
  1907.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1908.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1909.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1910.                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1911.                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0)]) << 8; /* convert to 16-bit */
  1912.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1913.                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1914.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1)]) << 8; /* to 16-bit */
  1915.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,LeftValue
  1916.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1917.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1918.                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1919.                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0) + 1]) << 8; /* convert to 16-bit */
  1920.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1921.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1922.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 8; /* to 16-bit */
  1923.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,LeftValue
  1924.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1925.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1926.              CheapDoLoop:
  1927.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1928.                     {
  1929.                         if (State->LoopState != eNoLoop)
  1930.                             {
  1931.                                 /* handle loop */
  1932.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1933.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1934.                                 goto CheapDoLoop;
  1935.                             }
  1936.                          else
  1937.                             {
  1938.                                 /* end of sample -- terminate */
  1939.                                 State->LoopState = eSampleFinished;
  1940.                                 goto BreakLoopPoint;
  1941.                             }
  1942.                     }
  1943.                 SampleCount -= 1;
  1944.             }
  1945.      BreakLoopPoint:
  1946.         ;
  1947.  
  1948.         State->SamplePosition = LocalSamplePosition;
  1949.     }
  1950.  
  1951.  
  1952. static void                        Sample_MonoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  1953.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1954.     {
  1955.         LongLongRec                    LocalSamplePosition;
  1956.         LongLongRec                    LocalSamplePositionDifferential;
  1957.         long                                LocalCurrentLoopEnd;
  1958.         FastFixedType                LocalOverallLoudness;
  1959.         signed short*                SampleData;
  1960.  
  1961.         LocalOverallLoudness = State->OverallLoudness;
  1962.         LocalSamplePosition = State->SamplePosition;
  1963.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1964.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1965.         SampleData = (signed short*)State->Data;
  1966.  
  1967.         while (SampleCount > 0)
  1968.             {
  1969.                 FastFixedType                LeftWeight;
  1970.                 long                                ArraySubscript;
  1971.                 signed long                    LeftValue;
  1972.                 signed long                    RightValue;
  1973.  
  1974.                 /* L+F(R-L) */
  1975.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1976.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1977.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1978.                     sizeof(SampleData[ArraySubscript]));
  1979.                 LeftValue = SampleData[ArraySubscript];
  1980.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1981.                     sizeof(SampleData[ArraySubscript + 1]));
  1982.                 RightValue = SampleData[ArraySubscript + 1];
  1983.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1984.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1985.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1986.              CheapDoLoop:
  1987.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1988.                     {
  1989.                         if (State->LoopState != eNoLoop)
  1990.                             {
  1991.                                 /* handle loop */
  1992.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1993.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1994.                                 goto CheapDoLoop;
  1995.                             }
  1996.                          else
  1997.                             {
  1998.                                 /* end of sample -- terminate */
  1999.                                 State->LoopState = eSampleFinished;
  2000.                                 goto BreakLoopPoint;
  2001.                             }
  2002.                     }
  2003.                 SampleCount -= 1;
  2004.             }
  2005.      BreakLoopPoint:
  2006.         ;
  2007.  
  2008.         State->SamplePosition = LocalSamplePosition;
  2009.     }
  2010.  
  2011.  
  2012. static void                        Sample_StereoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  2013.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2014.     {
  2015.         LongLongRec                    LocalSamplePosition;
  2016.         LongLongRec                    LocalSamplePositionDifferential;
  2017.         long                                LocalCurrentLoopEnd;
  2018.         FastFixedType                LocalLeftLoudness;
  2019.         FastFixedType                LocalRightLoudness;
  2020.         signed short*                SampleData;
  2021.  
  2022.         LocalLeftLoudness = State->LeftLoudness;
  2023.         LocalRightLoudness = State->RightLoudness;
  2024.         LocalSamplePosition = State->SamplePosition;
  2025.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2026.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2027.         SampleData = (signed short*)State->Data;
  2028.  
  2029.         while (SampleCount > 0)
  2030.             {
  2031.                 FastFixedType                LeftWeight;
  2032.                 long                                ArraySubscript;
  2033.                 signed long                    LeftValue;
  2034.                 signed long                    RightValue;
  2035.                 signed long                    CombinedValue;
  2036.  
  2037.                 /* L+F(R-L) */
  2038.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2039.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2040.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  2041.                     sizeof(SampleData[ArraySubscript]));
  2042.                 LeftValue = SampleData[ArraySubscript];
  2043.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  2044.                     sizeof(SampleData[ArraySubscript + 1]));
  2045.                 RightValue = SampleData[ArraySubscript + 1];
  2046.                 CombinedValue = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  2047.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,CombinedValue);
  2048.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,CombinedValue);
  2049.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2050.              CheapDoLoop:
  2051.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2052.                     {
  2053.                         if (State->LoopState != eNoLoop)
  2054.                             {
  2055.                                 /* handle loop */
  2056.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2057.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2058.                                 goto CheapDoLoop;
  2059.                             }
  2060.                          else
  2061.                             {
  2062.                                 /* end of sample -- terminate */
  2063.                                 State->LoopState = eSampleFinished;
  2064.                                 goto BreakLoopPoint;
  2065.                             }
  2066.                     }
  2067.                 SampleCount -= 1;
  2068.             }
  2069.      BreakLoopPoint:
  2070.         ;
  2071.  
  2072.         State->SamplePosition = LocalSamplePosition;
  2073.     }
  2074.  
  2075.  
  2076. static void                        Sample_MonoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  2077.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2078.     {
  2079.         LongLongRec                    LocalSamplePosition;
  2080.         LongLongRec                    LocalSamplePositionDifferential;
  2081.         long                                LocalCurrentLoopEnd;
  2082.         FastFixedType                LocalOverallLoudness;
  2083.         signed short*                SampleData;
  2084.  
  2085.         LocalOverallLoudness = State->OverallLoudness;
  2086.         LocalSamplePosition = State->SamplePosition;
  2087.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2088.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2089.         SampleData = (signed short*)State->Data;
  2090.  
  2091.         while (SampleCount > 0)
  2092.             {
  2093.                 FastFixedType                LeftWeight;
  2094.                 long                                ArraySubscript;
  2095.                 signed long                    LeftValue;
  2096.                 signed long                    RightValue;
  2097.  
  2098.                 /* L+F(R-L) */
  2099.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2100.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2101.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 0]),
  2102.                     sizeof(SampleData[2 * ArraySubscript + 0]));
  2103.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 1]),
  2104.                     sizeof(SampleData[2 * ArraySubscript + 1]));
  2105.                 LeftValue = ((signed long)SampleData[2 * ArraySubscript + 0]
  2106.                     + (signed long)SampleData[2 * ArraySubscript + 1]) >> 1;
  2107.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 0]),
  2108.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 0]));
  2109.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  2110.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  2111.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 0]
  2112.                     + (signed long)SampleData[2 * (ArraySubscript + 1) + 1]) >> 1;
  2113.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  2114.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2115.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2116.              CheapDoLoop:
  2117.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2118.                     {
  2119.                         if (State->LoopState != eNoLoop)
  2120.                             {
  2121.                                 /* handle loop */
  2122.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2123.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2124.                                 goto CheapDoLoop;
  2125.                             }
  2126.                          else
  2127.                             {
  2128.                                 /* end of sample -- terminate */
  2129.                                 State->LoopState = eSampleFinished;
  2130.                                 goto BreakLoopPoint;
  2131.                             }
  2132.                     }
  2133.                 SampleCount -= 1;
  2134.             }
  2135.      BreakLoopPoint:
  2136.         ;
  2137.  
  2138.         State->SamplePosition = LocalSamplePosition;
  2139.     }
  2140.  
  2141.  
  2142. static void                        Sample_StereoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  2143.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2144.     {
  2145.         LongLongRec                    LocalSamplePosition;
  2146.         LongLongRec                    LocalSamplePositionDifferential;
  2147.         long                                LocalCurrentLoopEnd;
  2148.         FastFixedType                LocalLeftLoudness;
  2149.         FastFixedType                LocalRightLoudness;
  2150.         signed short*                SampleData;
  2151.  
  2152.         LocalLeftLoudness = State->LeftLoudness;
  2153.         LocalRightLoudness = State->RightLoudness;
  2154.         LocalSamplePosition = State->SamplePosition;
  2155.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2156.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2157.         SampleData = (signed short*)State->Data;
  2158.  
  2159.         while (SampleCount > 0)
  2160.             {
  2161.                 FastFixedType                LeftWeight;
  2162.                 long                                ArraySubscript;
  2163.                 signed long                    LeftValue;
  2164.                 signed long                    RightValue;
  2165.  
  2166.                 /* L+F(R-L) */
  2167.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2168.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2169.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  2170.                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  2171.                 LeftValue = SampleData[2 * (ArraySubscript + 0)];
  2172.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  2173.                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  2174.                 RightValue = SampleData[2 * (ArraySubscript + 1)];
  2175.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,LeftValue
  2176.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2177.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  2178.                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  2179.                 LeftValue = SampleData[2 * (ArraySubscript + 0) + 1];
  2180.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  2181.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  2182.                 RightValue = SampleData[2 * (ArraySubscript + 1) + 1];
  2183.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,LeftValue
  2184.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2185.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2186.              CheapDoLoop:
  2187.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2188.                     {
  2189.                         if (State->LoopState != eNoLoop)
  2190.                             {
  2191.                                 /* handle loop */
  2192.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2193.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2194.                                 goto CheapDoLoop;
  2195.                             }
  2196.                          else
  2197.                             {
  2198.                                 /* end of sample -- terminate */
  2199.                                 State->LoopState = eSampleFinished;
  2200.                                 goto BreakLoopPoint;
  2201.                             }
  2202.                     }
  2203.                 SampleCount -= 1;
  2204.             }
  2205.      BreakLoopPoint:
  2206.         ;
  2207.  
  2208.         State->SamplePosition = LocalSamplePosition;
  2209.     }
  2210.  
  2211.  
  2212. static void                        Sample_NoOutput(SampleStateRec* State,
  2213.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2214.     {
  2215.     }
  2216.